package com.douma._2022_7_6;

import com.sun.corba.se.impl.interceptors.PICurrent;

import java.util.Scanner;

/**
 * 抖码算法，让算法学习变的简单有趣
 *
 * @作者 : 老汤
 */
public class 竖直四子棋 {

    // 表示一个棋子
    private static class Piece {
        boolean isRed; // 表示这个棋子是否属于红方的
        // 以下值读初始化为 1，因为只要这个棋子落在棋盘上，那么四个方向肯定会有一个棋子
        int vertical = 1; // 在水平方向，包含这个棋子，且颜色相同的连续棋子的个数
        int horizontal = 1; // 在竖直方向，包含这个棋子，且颜色相同的连续棋子的个数
        int mainDiagonal = 1; // 在主对角线方向，包含这个棋子，且颜色相同的连续棋子的个数
        int secondaryDiagonal = 1; // 在次对角线方向，包含这个棋子，且颜色相同的连续棋子的个数

        public String getColor() {
            if (isRed) {
                return "red";
            } else {
                return "blue";
            }
        }

        /**
         * 落子的步骤
         * @param seqNo 表示当前棋子的顺序号
         * @param row   表示当前棋子落在棋盘上的位置的行坐标
         * @param col   表示当前棋子落在棋盘上的位置的列坐标
         * @param pieces    表示棋盘
         * @return  如果这个棋子落下的话，已经存在连续的 4 个相同颜色的棋子，则返回这个棋子的顺序号
         *          否则返回 -1
         */
        public int luozi(int seqNo, int row, int col, Piece[][] pieces) {
            // 计算这个棋子是否属于红方
            this.isRed = seqNo % 2 == 1;

            // 统计这个棋子的竖直、水平、主对角线、次对角线连续相同颜色棋子的个数
            int nextRow, nextCol;

            // 竖直方向
            nextRow = row + 1;
            if (nextRow < pieces.length
                    && this.isRed == pieces[nextRow][col].isRed) {
                this.vertical += pieces[nextRow][col].vertical;
            }

            if (this.vertical == 4) return seqNo;

            // 水平方向
            // 1. 累加左边颜色相同的棋子
            nextCol = col - 1;
            if (nextCol >= 0
                    && pieces[row][nextCol] != null
                    && this.isRed == pieces[row][nextCol].isRed) {
                this.horizontal += pieces[row][nextCol].horizontal;
            }
            // 2. 累加右边颜色相同的棋子
            nextCol = col + 1;
            if (nextCol < pieces[row].length
                    && pieces[row][nextCol] != null
                    && this.isRed == pieces[row][nextCol].isRed) {
                this.horizontal += pieces[row][nextCol].horizontal;
            }
            if (this.horizontal == 4) return seqNo;

            // 主对角线方向
            // 1. 累加上主对角线方向颜色相同的棋子
            nextRow = row - 1;
            nextCol = col - 1;
            if (nextRow >= 0 && nextCol >= 0
                    && pieces[nextRow][nextCol] != null
                    && this.isRed == pieces[nextRow][nextCol].isRed) {
                this.mainDiagonal += pieces[nextRow][nextCol].mainDiagonal;
            }
            // 2. 累加下主对角线方向颜色相同的棋子
            nextRow = row + 1;
            nextCol = col + 1;
            if (nextRow < pieces.length && nextCol < pieces[nextRow].length
                    && pieces[nextRow][nextCol] != null
                    && this.isRed == pieces[nextRow][nextCol].isRed) {
                this.mainDiagonal += pieces[nextRow][nextCol].mainDiagonal;
            }
            if (this.mainDiagonal == 4) return seqNo;

            // 次对角线方向
            // 1. 累加上次对角线方向颜色相同的棋子
            nextRow = row - 1;
            nextCol = col + 1;
            if (nextRow >= 0 && nextCol < pieces[nextRow].length
                    && pieces[nextRow][nextCol] != null
                    && this.isRed == pieces[nextRow][nextCol].isRed) {
                this.secondaryDiagonal += pieces[nextRow][nextCol].secondaryDiagonal;
            }
            // 2. 累加下次对角线方向颜色相同的棋子
            nextRow = row + 1;
            nextCol = col - 1;
            if (nextRow < pieces.length && nextCol >= 0
                    && pieces[nextRow][nextCol] != null
                    && this.isRed == pieces[nextRow][nextCol].isRed) {
                this.secondaryDiagonal += pieces[nextRow][nextCol].secondaryDiagonal;
            }
            if (this.secondaryDiagonal == 4) return seqNo;

            return -1;
        }
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        int m = sc.nextInt();
        int n = sc.nextInt();
        sc.nextLine();

        // 声明一个 m*n 的棋盘
        Piece[][] pieces = new Piece[m][n];
        // 记录棋盘中每一列已经存放的棋子的个数
        int[] colsUsed = new int[n];
        // 判断是否有赢者
        boolean hasWinner = false;
        String[] cols = sc.nextLine().split(" ");
        for (int i = 0; i < cols.length; i++) {
            // 计算当前棋子落在棋盘中的位置：列坐标和行坐标
            int col = Integer.valueOf(cols[i]) - 1;
            int row = m - colsUsed[col] - 1;
            // 当前这一列棋子数 +1
            colsUsed[col]++;
            // 棋子的顺序号
            int seqNo = i + 1;

            // 非法落子步骤有两种，一是列的编号超过棋盘范围，二是一个已经落满子的列上落子
            if (col >= n || row < 0) {
                System.out.println(seqNo + ",error");
            }

            // 创建一个棋子
            Piece piece = new Piece();
            // 将这个棋子落到棋盘中的 [row, col] 上
            int res = piece.luozi(seqNo, row, col, pieces);
            // 如果 res != 0，说明有赢者
            if (res != -1) {
                hasWinner = true;
                System.out.println(seqNo + "," + piece.getColor());
                break;
            }
            pieces[row][col] = piece;
        }

        if (!hasWinner) {
            System.out.println("0,draw");
        }

        sc.close();
    }
}
